home *** CD-ROM | disk | FTP | other *** search
/ Personal Computer World 2009 February / PCWFEB09.iso / Software / Linux / Kubuntu 8.10 / kubuntu-8.10-desktop-i386.iso / casper / filesystem.squashfs / usr / share / pyshared / PIL / FpxImagePlugin.py < prev    next >
Text File  |  2006-12-03  |  6KB  |  227 lines
  1. #
  2. # THIS IS WORK IN PROGRESS
  3. #
  4. # The Python Imaging Library.
  5. # $Id: FpxImagePlugin.py 2134 2004-10-06 08:55:20Z fredrik $
  6. #
  7. # FlashPix support for PIL
  8. #
  9. # History:
  10. # 97-01-25 fl   Created (reads uncompressed RGB images only)
  11. #
  12. # Copyright (c) Secret Labs AB 1997.
  13. # Copyright (c) Fredrik Lundh 1997.
  14. #
  15. # See the README file for information on usage and redistribution.
  16. #
  17.  
  18.  
  19. __version__ = "0.1"
  20.  
  21.  
  22. import string
  23.  
  24. import Image, ImageFile
  25. from OleFileIO import *
  26.  
  27.  
  28. # we map from colour field tuples to (mode, rawmode) descriptors
  29. MODES = {
  30.     # opacity
  31.     (0x00007ffe): ("A", "L"),
  32.     # monochrome
  33.     (0x00010000,): ("L", "L"),
  34.     (0x00018000, 0x00017ffe): ("RGBA", "LA"),
  35.     # photo YCC
  36.     (0x00020000, 0x00020001, 0x00020002): ("RGB", "YCC;P"),
  37.     (0x00028000, 0x00028001, 0x00028002, 0x00027ffe): ("RGBA", "YCCA;P"),
  38.     # standard RGB (NIFRGB)
  39.     (0x00030000, 0x00030001, 0x00030002): ("RGB","RGB"),
  40.     (0x00038000, 0x00038001, 0x00038002, 0x00037ffe): ("RGBA","RGBA"),
  41. }
  42.  
  43. #
  44. # --------------------------------------------------------------------
  45.  
  46. def _accept(prefix):
  47.     return prefix[:8] == MAGIC
  48.  
  49. ##
  50. # Image plugin for the FlashPix images.
  51.  
  52. class FpxImageFile(ImageFile.ImageFile):
  53.  
  54.     format = "FPX"
  55.     format_description = "FlashPix"
  56.  
  57.     def _open(self):
  58.         #
  59.         # read the OLE directory and see if this is a likely
  60.         # to be a FlashPix file
  61.  
  62.         try:
  63.             self.ole = OleFileIO(self.fp)
  64.         except IOError:
  65.             raise SyntaxError, "not an FPX file; invalid OLE file"
  66.  
  67.         if self.ole.root.clsid != "56616700-C154-11CE-8553-00AA00A1F95B":
  68.             raise SyntaxError, "not an FPX file; bad root CLSID"
  69.  
  70.         self._open_index(1)
  71.  
  72.     def _open_index(self, index = 1):
  73.         #
  74.         # get the Image Contents Property Set
  75.  
  76.         prop = self.ole.getproperties([
  77.             "Data Object Store %06d" % index,
  78.             "\005Image Contents"
  79.         ])
  80.  
  81.         # size (highest resolution)
  82.  
  83.         self.size = prop[0x1000002], prop[0x1000003]
  84.  
  85.         size = max(self.size)
  86.         i = 1
  87.         while size > 64:
  88.             size = size / 2
  89.             i = i + 1
  90.         self.maxid = i - 1
  91.  
  92.         # mode.  instead of using a single field for this, flashpix
  93.         # requires you to specify the mode for each channel in each
  94.         # resolution subimage, and leaves it to the decoder to make
  95.         # sure that they all match.  for now, we'll cheat and assume
  96.         # that this is always the case.
  97.  
  98.         id = self.maxid << 16
  99.  
  100.         s = prop[0x2000002|id]
  101.  
  102.         colors = []
  103.         for i in range(i32(s, 4)):
  104.             # note: for now, we ignore the "uncalibrated" flag
  105.             colors.append(i32(s, 8+i*4) & 0x7fffffff)
  106.  
  107.         self.mode, self.rawmode = MODES[tuple(colors)]
  108.  
  109.         # load JPEG tables, if any
  110.         self.jpeg = {}
  111.         for i in range(256):
  112.             id = 0x3000001|(i << 16)
  113.             if prop.has_key(id):
  114.                 self.jpeg[i] = prop[id]
  115.  
  116.         # print len(self.jpeg), "tables loaded"
  117.  
  118.         self._open_subimage(1, self.maxid)
  119.  
  120.     def _open_subimage(self, index = 1, subimage = 0):
  121.         #
  122.         # setup tile descriptors for a given subimage
  123.  
  124.         stream = [
  125.             "Data Object Store %06d" % index,
  126.             "Resolution %04d" % subimage,
  127.             "Subimage 0000 Header"
  128.         ]
  129.  
  130.         fp = self.ole.openstream(stream)
  131.  
  132.         # skip prefix
  133.         p = fp.read(28)
  134.  
  135.         # header stream
  136.         s = fp.read(36)
  137.  
  138.         size = i32(s, 4), i32(s, 8)
  139.         tilecount = i32(s, 12)
  140.         tilesize = i32(s, 16), i32(s, 20)
  141.         channels = i32(s, 24)
  142.         offset = i32(s, 28)
  143.         length = i32(s, 32)
  144.  
  145.         # print size, self.mode, self.rawmode
  146.  
  147.         if size != self.size:
  148.             raise IOError, "subimage mismatch"
  149.  
  150.         # get tile descriptors
  151.         fp.seek(28 + offset)
  152.         s = fp.read(i32(s, 12) * length)
  153.  
  154.         x = y = 0
  155.         xsize, ysize = size
  156.         xtile, ytile = tilesize
  157.         self.tile = []
  158.  
  159.         for i in range(0, len(s), length):
  160.  
  161.             compression = i32(s, i+8)
  162.  
  163.             if compression == 0:
  164.                 self.tile.append(("raw", (x,y,x+xtile,y+ytile),
  165.                         i32(s, i) + 28, (self.rawmode)))
  166.  
  167.             elif compression == 1:
  168.  
  169.                 # FIXME: the fill decoder is not implemented
  170.                 self.tile.append(("fill", (x,y,x+xtile,y+ytile),
  171.                         i32(s, i) + 28, (self.rawmode, s[12:16])))
  172.  
  173.             elif compression == 2:
  174.  
  175.                 internal_color_conversion = ord(s[14])
  176.                 jpeg_tables = ord(s[15])
  177.                 rawmode = self.rawmode
  178.  
  179.                 if internal_color_conversion:
  180.                     # The image is stored as usual (usually YCbCr).
  181.                     if rawmode == "RGBA":
  182.                         # For "RGBA", data is stored as YCbCrA based on
  183.                         # negative RGB. The following trick works around
  184.                         # this problem :
  185.                         jpegmode, rawmode = "YCbCrK", "CMYK"
  186.                     else:
  187.                         jpegmode = None # let the decoder decide
  188.  
  189.                 else:
  190.                     # The image is stored as defined by rawmode
  191.                     jpegmode = rawmode
  192.  
  193.                 self.tile.append(("jpeg", (x,y,x+xtile,y+ytile),
  194.                         i32(s, i) + 28, (rawmode, jpegmode)))
  195.  
  196.                 # FIXME: jpeg tables are tile dependent; the prefix
  197.                 # data must be placed in the tile descriptor itself!
  198.  
  199.                 if jpeg_tables:
  200.                     self.tile_prefix = self.jpeg[jpeg_tables]
  201.  
  202.             else:
  203.                 raise IOError, "unknown/invalid compression"
  204.  
  205.             x = x + xtile
  206.             if x >= xsize:
  207.                 x, y = 0, y + ytile
  208.                 if y >= ysize:
  209.                     break # isn't really required
  210.  
  211.         self.stream = stream
  212.         self.fp = None
  213.  
  214.     def load(self):
  215.  
  216.         if not self.fp:
  217.             self.fp = self.ole.openstream(self.stream[:2] + ["Subimage 0000 Data"])
  218.  
  219.         ImageFile.ImageFile.load(self)
  220.  
  221. #
  222. # --------------------------------------------------------------------
  223.  
  224. Image.register_open("FPX", FpxImageFile, _accept)
  225.  
  226. Image.register_extension("FPX", ".fpx")
  227.